/*
 * 描          述:  <描述>
 * 修  改   人:  
 * 修改时间:  
 * <修改描述:>
 */
package com.tx.component.sendsms.service;

import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.persistence.Column;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.PropertyAccessorFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.web.client.ResourceAccessException;

import com.thoughtworks.xstream.XStream;
import com.tx.component.sendsms.config.SmsTemplateConfig;
import com.tx.component.sendsms.config.SmsTemplateConfigs;
import com.tx.component.sendsms.dao.SmsTemplateDao;
import com.tx.component.sendsms.model.SendSMSWTChannelEnum;
import com.tx.component.sendsms.model.SmsTemplate;
import com.tx.component.sendsms.model.SmsTemplateCode;
import com.tx.core.exceptions.util.AssertUtils;
import com.tx.core.paged.model.PagedList;
import com.tx.core.querier.model.Filter;
import com.tx.core.querier.model.Querier;
import com.tx.core.querier.model.QuerierBuilder;
import com.tx.core.util.ClassScanUtils;
import com.tx.core.util.XstreamUtils;

/**
 * SmsTemplate的业务层[SmsTemplateService]
 * <功能详细描述>
 * 
 * @author  
 * @version [版本号]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class SmsTemplateService implements InitializingBean {
    
    /** resourceResolver */
    private static final ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
    
    /** 日志记录器 */
    private Logger logger = LoggerFactory.getLogger(SmsTemplateService.class);
    
    /**短信模板配置读取器*/
    private XStream smsTemplateConfigXstream = XstreamUtils
            .getXstream(SmsTemplateConfigs.class);
    
    /** 账户类型MAP */
    protected final Map<String, SmsTemplateCode> smsTemplateCodeMap = new HashMap<>();
    
    /** 枚举所在的包 */
    private String enumBasePackages = "com.tx";
    
    /** 短信模板配置的路径 */
    private String configLocation;
    
    /** 事务template */
    private TransactionTemplate transactionTemplate;
    
    /** 短信模板持久层 */
    private SmsTemplateDao smsTemplateDao;
    
    /** <默认构造函数> */
    public SmsTemplateService() {
        super();
    }
    
    /** <默认构造函数> */
    public SmsTemplateService(String enumBasePackages, String configLocation,
            SmsTemplateDao smsTemplateDao,
            TransactionTemplate transactionTemplate) {
        super();
        this.enumBasePackages = enumBasePackages;
        this.configLocation = configLocation;
        this.smsTemplateDao = smsTemplateDao;
        this.transactionTemplate = transactionTemplate;
    }
    
    /**
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        //初始化短信模板编码
        initSMSTemplateCode();
        //TypeHandler4SmsTemplateCode.SMS_TEMPLATE_CODE_MAP.putAll(this.smsTemplateCodeMap);
        
        this.transactionTemplate
                .executeWithoutResult(status -> initConfigLocation());
        
    }
    
    /**
     * 初始化短信模板编码<br/>
     * <功能详细描述> [参数说明]
     * 
     * @return void [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    private void initSMSTemplateCode() {
        Set<Class<? extends SmsTemplateCode>> clazzSet = ClassScanUtils
                .scanByParentClass(SmsTemplateCode.class,
                        this.enumBasePackages);
        
        /** 第三方账户类型 */
        for (Class<? extends SmsTemplateCode> clazzTemp : clazzSet) {
            if (!clazzTemp.isEnum()) {
                continue;
            }
            SmsTemplateCode[] codes = clazzTemp.getEnumConstants();
            for (SmsTemplateCode codeTemp : codes) {
                AssertUtils.notEmpty(codeTemp.getCode(),
                        "SmsTemplateCode.code is empty.");
                AssertUtils.notEmpty(codeTemp.getName(),
                        "SmsTemplateCode.name is empty.");
                
                this.smsTemplateCodeMap.put(codeTemp.getCode().toUpperCase(),
                        codeTemp);
            }
        }
    }
    
    /**
     * 根据配置文件对配置模板进行初始化<br/>
     * <功能详细描述> [参数说明]
     * 
     * @return void [返回类型说明]
     * @throws IOException 
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    private void initConfigLocation() {
        if (StringUtils.isBlank(this.configLocation)) {
            return;
        }
        String[] locations = StringUtils
                .splitByWholeSeparator(this.configLocation, ",");
        if (ArrayUtils.isEmpty(locations)) {
            return;
        }
        
        //解析配置资源
        Set<org.springframework.core.io.Resource> configResources = new HashSet<>();
        for (String locationTemp : locations) {
            if (StringUtils.isBlank(locationTemp)) {
                continue;
            }
            try {
                configResources.addAll(Arrays
                        .asList(resourceResolver.getResources(locationTemp)));
            } catch (IOException e) {
                throw new ResourceAccessException(e.getMessage(), e);
            }
        }
        
        //配置资源读取，并解析为配置
        for (org.springframework.core.io.Resource configResource : configResources) {
            if (!configResource.exists()) {
                logger.info("configLocation resource is not exist.");
                continue;
            }
            //解析权限配置文件
            try (InputStream in = configResource.getInputStream()) {
                SmsTemplateConfigs parser = (SmsTemplateConfigs) smsTemplateConfigXstream
                        .fromXML(in);
                if (parser.getChannel() == null) {
                    logger.warn("短信模板配置文件解析对应渠道错误，该资源放弃解析. Resource:{}",
                            new Object[] { configResource.getURL().getPath() });
                    continue;
                }
                //初始化权限类型配置
                if (CollectionUtils.isEmpty(parser.getTemplates())) {
                    continue;
                }
                //短信模板配置
                for (SmsTemplateConfig config : parser.getTemplates()) {
                    if (StringUtils.isEmpty(config.getCode())) {
                        logger.warn("短信模板解析错误，该资源中存在模板code为空. Resource:{}",
                                new Object[] {
                                        configResource.getURL().getPath() });
                        continue;
                    }
                    SmsTemplateCode code = this.smsTemplateCodeMap
                            .get(config.getCode());
                    if (code == null) {
                        logger.warn(
                                "短信模板解析错误，该资源中存在模板code对应的枚举不存在. Resource:{}, code:{}",
                                new Object[] {
                                        configResource.getURL().getPath(),
                                        config.getCode() });
                        continue;
                    }
                    //初始化短信模板
                    initSmsTemplate(code, parser.getChannel(), config);
                }
            } catch (IOException e) {
                throw new ResourceAccessException(e.getMessage(), e);
            }
        }
    }
    
    /**
     * 初始化短信模板<br/>
     * <功能详细描述>
     * @param channel
     * @param config [参数说明]
     * 
     * @return void [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    private void initSmsTemplate(SmsTemplateCode code,
            SendSMSWTChannelEnum channel, SmsTemplateConfig config) {
        //根据编码和渠道查询短信模板
        SmsTemplate st = findByCode(code.getCode(), channel);
        if (st == null) {
            SmsTemplate newST = new SmsTemplate();
            //设置编码和名称
            newST.setCode(code.getCode());
            newST.setName(code.getName());
            //设置渠道
            newST.setChannel(channel);
            newST.setValid(true);
            newST.setModifiable(false);
            //设置模板值
            newST.setSignName(config.getSignName());
            newST.setTemplateCode(config.getTemplateCode());
            newST.setTemplateContent(config.getTemplateContent());
            newST.setTemplateParameters(config.getTemplateParameters());
            
            Date now = new Date();
            newST.setCreateDate(now);
            newST.setLastUpdateDate(now);
            //插入模板实例
            this.smsTemplateDao.insert(newST);
        } else {
            if (!StringUtils.equals(code.getName(), st.getName())
                    || !StringUtils.equals(config.getSignName(),
                            st.getSignName())
                    || !StringUtils.equals(config.getTemplateCode(),
                            st.getTemplateCode())
                    || !StringUtils.equals(config.getTemplateContent(),
                            st.getTemplateContent())
                    || !StringUtils.equals(config.getTemplateParameters(),
                            st.getTemplateParameters())) {
                st.setName(code.getName());
                st.setSignName(config.getSignName());
                st.setTemplateCode(config.getTemplateCode());
                st.setTemplateContent(config.getTemplateContent());
                st.setTemplateParameters(config.getTemplateParameters());
                st.setLastUpdateDate(new Date());
                //更新短信模板
                updateById(st);
            }
        }
    }
    
    /**
     * 新增SmsTemplate实例<br/>
     * 将smsTemplate插入数据库中保存
     * 1、如果smsTemplate 为空时抛出参数为空异常
     * 2、如果smsTemplate 中部分必要参数为非法值时抛出参数不合法异常
     * 
     * @param smsTemplate [参数说明]
     * @return void [返回类型说明]
     * @exception throws
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public void insert(SmsTemplate smsTemplate) {
        //验证参数是否合法
        AssertUtils.notNull(smsTemplate, "smsTemplate is null.");
        AssertUtils.notEmpty(smsTemplate.getCode(),
                "smsTemplate.code is empty.");
        AssertUtils.notEmpty(smsTemplate.getName(),
                "smsTemplate.name is empty.");
        AssertUtils.notEmpty(smsTemplate.getChannel(),
                "smsTemplate.channel is empty.");
        
        //为添加的数据需要填入默认值的字段填入默认值
        smsTemplate.setLastUpdateDate(new Date());
        smsTemplate.setValid(true);
        smsTemplate.setModifiable(true);
        smsTemplate.setCreateDate(new Date());
        
        //调用数据持久层对实例进行持久化操作
        this.smsTemplateDao.insert(smsTemplate);
    }
    
    /**
     * 根据id删除SmsTemplate实例
     * 1、如果入参数为空，则抛出异常
     * 2、执行删除后，将返回数据库中被影响的条数 > 0，则返回true
     *
     * @param id
     * @return boolean 删除的条数>0则为true [返回类型说明]
     * @exception throws 
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean deleteById(String id) {
        AssertUtils.notEmpty(id, "id is empty.");
        
        SmsTemplate condition = new SmsTemplate();
        condition.setId(id);
        
        int resInt = this.smsTemplateDao.delete(condition);
        boolean flag = resInt > 0;
        return flag;
    }
    
    /**
     * 根据code删除SmsTemplate实例
     * 1、当code为empty时抛出异常
     * 2、执行删除后，将返回数据库中被影响的条数 > 0，则返回true
     *
     * @param code
     * @return SmsTemplate [返回类型说明]
     * @exception throws
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean deleteByCode(String code, SendSMSWTChannelEnum channel) {
        AssertUtils.notNull(code, "code is null.");
        AssertUtils.notNull(channel, "channel is null.");
        
        SmsTemplate condition = new SmsTemplate();
        condition.setCode(code);
        condition.setChannel(channel);
        
        int resInt = this.smsTemplateDao.delete(condition);
        boolean flag = resInt > 0;
        return flag;
    }
    
    /**
     * 根据id查询SmsTemplate实例
     * 1、当id为empty时抛出异常
     *
     * @param id
     * @return SmsTemplate [返回类型说明]
     * @exception throws
     * @see [类、类#方法、类#成员]
     */
    public SmsTemplate findById(String id) {
        AssertUtils.notEmpty(id, "id is empty.");
        
        SmsTemplate condition = new SmsTemplate();
        condition.setId(id);
        
        SmsTemplate res = this.smsTemplateDao.find(condition);
        return res;
    }
    
    /**
     * 根据code查询SmsTemplate实例
     * 1、当code为empty时抛出异常
     *
     * @param code
     * @return SmsTemplate [返回类型说明]
     * @exception throws
     * @see [类、类#方法、类#成员]
     */
    public SmsTemplate findByCode(String code, SendSMSWTChannelEnum channel) {
        AssertUtils.notEmpty(code, "code is empty.");
        AssertUtils.notNull(channel, "channel is null.");
        
        SmsTemplate condition = new SmsTemplate();
        condition.setCode(code);
        condition.setChannel(channel);
        
        SmsTemplate res = this.smsTemplateDao.find(condition);
        return res;
    }
    
    /**
     * 如果存在多个渠道都有同一个验证码的时候<br/>
     *    默认使用第一个
     * <功能详细描述>
     * @param code
     * @return [参数说明]
     * 
     * @return SmsTemplate [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public SmsTemplate findFirstByCode(String code) {
        AssertUtils.notEmpty(code, "code is empty.");
        
        Map<String, Object> params = new HashMap<>();
        params.put("code", code);
        List<SmsTemplate> resList = queryList(true, params);
        
        if (CollectionUtils.isEmpty(resList)) {
            return null;
        } else if (resList.size() == 1) {
            return resList.get(0);
        } else {
            return resList.get(0);
        }
    }
    
    /**
     * 查询SmsTemplate实例列表
     * <功能详细描述>
     * @param valid
     * @param params      
     * @return [参数说明]
     * 
     * @return List<SmsTemplate> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public List<SmsTemplate> queryList(Boolean valid,
            Map<String, Object> params) {
        //生成查询条件
        params = params == null ? new HashMap<String, Object>() : params;
        params.put("valid", valid);
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        List<SmsTemplate> resList = this.smsTemplateDao.queryList(params);
        
        return resList;
    }
    
    /**
     * 查询SmsTemplate实例列表
     * <功能详细描述>
     * @param valid
     * @param querier      
     * @return [参数说明]
     * 
     * @return List<SmsTemplate> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public List<SmsTemplate> queryList(Boolean valid, Querier querier) {
        //生成查询条件
        querier = querier == null ? QuerierBuilder.newInstance().querier()
                : querier;
        if (valid != null) {
            querier.getFilters().add(Filter.eq("valid", valid));
        }
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        List<SmsTemplate> resList = this.smsTemplateDao.queryList(querier);
        
        return resList;
    }
    
    /**
     * 分页查询SmsTemplate实例列表
     * <功能详细描述>
     * @param valid
     * @param params    
     * @param pageIndex 当前页index从1开始计算
     * @param pageSize 每页显示行数
     * 
     * <功能详细描述>
     * @return [参数说明]
     * 
     * @return List<SmsTemplate> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public PagedList<SmsTemplate> queryPagedList(Boolean valid,
            Map<String, Object> params, int pageIndex, int pageSize) {
        //生成查询条件
        params = params == null ? new HashMap<String, Object>() : params;
        params.put("valid", valid);
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        PagedList<SmsTemplate> resPagedList = this.smsTemplateDao
                .queryPagedList(params, pageIndex, pageSize);
        
        return resPagedList;
    }
    
    /**
     * 分页查询SmsTemplate实例列表
     * <功能详细描述>
     * @param valid
     * @param querier    
     * @param pageIndex 当前页index从1开始计算
     * @param pageSize 每页显示行数
     * 
     * <功能详细描述>
     * @return [参数说明]
     * 
     * @return List<SmsTemplate> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public PagedList<SmsTemplate> queryPagedList(Boolean valid, Querier querier,
            int pageIndex, int pageSize) {
        //生成查询条件
        querier = querier == null ? QuerierBuilder.newInstance().querier()
                : querier;
        if (valid != null) {
            querier.getFilters().add(Filter.eq("valid", valid));
        }
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        PagedList<SmsTemplate> resPagedList = this.smsTemplateDao
                .queryPagedList(querier, pageIndex, pageSize);
        
        return resPagedList;
    }
    
    /**
     * 查询SmsTemplate实例数量<br/>
     * <功能详细描述>
     * @param valid
     * @param params      
     * @return [参数说明]
     * 
     * @return List<SmsTemplate> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public int count(Boolean valid, Map<String, Object> params) {
        //生成查询条件
        params = params == null ? new HashMap<String, Object>() : params;
        params.put("valid", valid);
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        int res = this.smsTemplateDao.count(params);
        
        return res;
    }
    
    /**
     * 查询SmsTemplate实例数量<br/>
     * <功能详细描述>
     * @param valid
     * @param querier      
     * @return [参数说明]
     * 
     * @return List<SmsTemplate> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public int count(Boolean valid, Querier querier) {
        //生成查询条件
        querier = querier == null ? QuerierBuilder.newInstance().querier()
                : querier;
        if (valid != null) {
            querier.getFilters().add(Filter.eq("valid", valid));
        }
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        int res = this.smsTemplateDao.count(querier);
        
        return res;
    }
    
    /**
     * 判断SmsTemplate实例是否已经存在<br/>
     * <功能详细描述>
     * @param key2valueMap
     * @param excludeId
     * @return
     * 
     * @return int [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public boolean exists(Map<String, Object> key2valueMap, String excludeId) {
        AssertUtils.notEmpty(key2valueMap, "key2valueMap is empty");
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        int res = this.smsTemplateDao.count(key2valueMap, excludeId);
        
        return res > 0;
    }
    
    /**
     * 判断SmsTemplate实例是否已经存在<br/>
     * <功能详细描述>
     * @param key2valueMap
     * @param excludeId
     * @return
     * 
     * @return int [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public boolean exists(Querier querier, String excludeId) {
        AssertUtils.notNull(querier, "querier is null.");
        
        //根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法
        int res = this.smsTemplateDao.count(querier, excludeId);
        
        return res > 0;
    }
    
    /**
     * 根据id更新SmsTemplate实例<br/>
     * <功能详细描述>
     * @param smsTemplate
     * @return [参数说明]
     * 
     * @return boolean [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean updateById(String id, Map<String, Object> updateRowMap) {
        //验证参数是否合法，必填字段是否填写
        AssertUtils.notEmpty(id, "id is empty.");
        AssertUtils.notEmpty(updateRowMap, "updateRowMap is empty.");
        
        updateRowMap.put("lastUpdateDate", new Date());
        boolean flag = this.smsTemplateDao.update(id, updateRowMap);
        //如果需要大于1时，抛出异常并回滚，需要在这里修改
        return flag;
    }
    
    /**
     * 根据id更新SmsTemplate实例<br/>
     * <功能详细描述>
     * @param smsTemplate
     * @return [参数说明]
     * 
     * @return boolean [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean updateById(String id, SmsTemplate smsTemplate) {
        //验证参数是否合法，必填字段是否填写
        AssertUtils.notNull(smsTemplate, "smsTemplate is null.");
        AssertUtils.notEmpty(id, "id is empty.");
        AssertUtils.notEmpty(smsTemplate.getName(),
                "smsTemplate.name is empty.");
        AssertUtils.notEmpty(smsTemplate.getChannel(),
                "smsTemplate.channel is empty.");
        
        //生成需要更新字段的hashMap
        Map<String, Object> updateRowMap = new HashMap<String, Object>();
        //需要更新的字段
        updateRowMap.put("name", smsTemplate.getName());
        updateRowMap.put("modifiable", smsTemplate.isModifiable());
        updateRowMap.put("remark", smsTemplate.getRemark());
        updateRowMap.put("templateCode", smsTemplate.getTemplateCode());
        updateRowMap.put("templateParameters",
                smsTemplate.getTemplateParameters());
        updateRowMap.put("templateContent", smsTemplate.getTemplateContent());
        updateRowMap.put("lastUpdateDate", new Date());
        
        boolean flag = this.smsTemplateDao.update(id, updateRowMap);
        //如果需要大于1时，抛出异常并回滚，需要在这里修改
        return flag;
    }
    
    /**
     * 根据id更新SmsTemplate实例<br/>
     * <功能详细描述>
     * @param smsTemplate
     * @return [参数说明]
     * 
     * @return boolean [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean updateById(SmsTemplate smsTemplate) {
        //验证参数是否合法，必填字段是否填写
        AssertUtils.notNull(smsTemplate, "smsTemplate is null.");
        AssertUtils.notEmpty(smsTemplate.getId(), "smsTemplate.id is empty.");
        
        Map<String, Object> updateRowMap = new HashMap<String, Object>();
        BeanWrapper bw = PropertyAccessorFactory
                .forBeanPropertyAccess(smsTemplate);
        for (PropertyDescriptor pd : bw.getPropertyDescriptors()) {
            if (pd.getWriteMethod() == null || pd.getReadMethod() == null) {
                continue;
            }
            if ("id".equals(pd.getName())) {
                continue;
            }
            TypeDescriptor td1 = bw.getPropertyTypeDescriptor(pd.getName());
            if (td1.hasAnnotation(Column.class)
                    && !td1.getAnnotation(Column.class).updatable()) {
                continue;
            }
            updateRowMap.put(pd.getName(), bw.getPropertyValue(pd.getName()));
        }
        boolean flag = updateById(smsTemplate.getId(), updateRowMap);
        //如果需要大于1时，抛出异常并回滚，需要在这里修改
        return flag;
    }
    
    /**
     * 根据id禁用SmsTemplate<br/>
     * <功能详细描述>
     * @param id
     * @return [参数说明]
     * 
     * @return boolean [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean disableById(String id) {
        AssertUtils.notEmpty(id, "id is empty.");
        
        //生成条件
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("id", id);
        params.put("valid", false);
        params.put("lastUpdateDate", new Date());
        
        boolean flag = this.smsTemplateDao.update(params) > 0;
        
        return flag;
    }
    
    /**
     * 根据id启用SmsTemplate<br/>
     * <功能详细描述>
     * @param id
     * @return [参数说明]
     * 
     * @return boolean [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    @Transactional
    public boolean enableById(String id) {
        AssertUtils.notEmpty(id, "id is empty.");
        
        //生成查询条件
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("id", id);
        params.put("valid", true);
        params.put("lastUpdateDate", new Date());
        
        boolean flag = this.smsTemplateDao.update(params) > 0;
        
        return flag;
    }
    
    /**
     * 获取第三方账户类型集合<br/>
     * <功能详细描述>
     * @return [参数说明]
     * 
     * @return List<SmsTemplateCode> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public Map<String, SmsTemplateCode> getTemplateCodeMap() {
        Map<String, SmsTemplateCode> res = MapUtils
                .unmodifiableMap(this.smsTemplateCodeMap);
        return res;
    }
    
    /**
     * 获取登陆插件<br/>
     * <功能详细描述>
     * @param code
     * @return [参数说明]
     * 
     * @return LoginPlugin<LoginPluginConfig> [返回类型说明]
     * @exception throws [异常类型] [异常说明]
     * @see [类、类#方法、类#成员]
     */
    public SmsTemplateCode getTemplateCode(String code) {
        AssertUtils.notEmpty(code, "code is empty.");
        
        SmsTemplateCode smsTemplateCode = this.smsTemplateCodeMap
                .get(code.toUpperCase());
        return smsTemplateCode;
    }
    
    /**
     * @return 返回 smsTemplateDao
     */
    public SmsTemplateDao getSmsTemplateDao() {
        return smsTemplateDao;
    }
    
    /**
     * @param 对smsTemplateDao进行赋值
     */
    public void setSmsTemplateDao(SmsTemplateDao smsTemplateDao) {
        this.smsTemplateDao = smsTemplateDao;
    }
}
